package lin

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"
)

func 键值列表_类型筛选(原始数据 any) (返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case string:
		return
	case int:
		return
	case bool:
		return
	case byte:
		return
	case nil:
		return
	case float64:
		return
	case float32:
		return
	case int8:
		return
	case int16:
		return
	case int32:
		return
	case int64:
		return
	case uint:
		return
	case uint16:
		return
	case uint32:
		return
	case uint64:
		return
	case []byte:
		return
	case time.Time:
		return
	case []map[string]any:
		for _, v := range 当前值 {
			返回_错误 = 键值列表_类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	case map[string]any:
		for _, v := range 当前值 {
			返回_错误 = 键值列表_类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	case []any:
		for _, v := range 当前值 {
			返回_错误 = 键值列表_类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	default:
		返回_错误 = fmt.Errorf("错误: 类型 %T 不是支持的基本类型", 当前值)
		return
	}

}

func 键值列表_深拷贝(原始数据 any) (返回_值 any, 返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值 = 深拷贝(当前值)
		return
	case map[string]any:
		返回_值 = 深拷贝(当前值)
		return
	case []map[string]any:
		转换值 := make([]any, len(当前值))
		for i, v := range 当前值 {
			转换值[i] = v
		}
		返回_值 = 深拷贝(转换值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any  或者 []map[string]any 当前数据类型错误")
		return
	}

}

func 深拷贝(原始数据 any) (返回_值 any) {
	if 条件map, ok := 原始数据.(map[string]any); ok {
		新map := make(map[string]any)
		for k, v := range 条件map {
			新map[k] = 深拷贝(v)
		}
		返回_值 = 新map
		return
	} else if 条件切片, ok := 原始数据.([]any); ok {
		新切片 := make([]any, len(条件切片))
		for k, v := range 条件切片 {
			新切片[k] = 深拷贝(v)
		}
		返回_值 = 新切片
		return
	}
	返回_值 = 原始数据
	return
}

func 键值列表_JSON之前处理(原始数据 any) (返回_值 any) {
	if 条件map, ok := 原始数据.(map[string]any); ok {
		新map := make(map[string]any)
		for k, v := range 条件map {
			switch 当前值 := v.(type) {
			case time.Time:
				新map[k] = 键值列表_JSON之前处理(当前值.Format("2006-01-02 15:04:05"))
			case []byte:
				新map[k] = 键值列表_JSON之前处理(string(当前值))

			default:
				新map[k] = 键值列表_JSON之前处理(v)

			}
		}
		返回_值 = 新map
		return
	} else if 条件切片, ok := 原始数据.([]any); ok {
		新切片 := make([]any, len(条件切片))
		for k, v := range 条件切片 {
			switch 当前值 := v.(type) {
			case time.Time:
				新切片[k] = 键值列表_JSON之前处理(当前值.Format("2006-01-02 15:04:05"))
			case []byte:
				新切片[k] = 键值列表_JSON之前处理(string(当前值))

			default:
				新切片[k] = 键值列表_JSON之前处理(v)

			}
		}
		返回_值 = 新切片
		return
	}
	返回_值 = 原始数据
	return
}

func 键值列表_置值(原始数据 any, 键组路径 []string, 值 any) (返回_错误 error) {
	返回_错误 = 键值列表_类型筛选(值)
	if 返回_错误 != nil {
		return
	}
	新值, err := 键值列表_深拷贝(值)
	if err != nil {
		switch 当前值 := 原始数据.(type) {
		case []any:
			_, 返回_错误 = 置值(当前值, 键组路径, 值)
			return
		case map[string]any:
			_, 返回_错误 = 置值(当前值, 键组路径, 值)
			return
		default:
			返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case []any:
		_, 返回_错误 = 置值(当前值, 键组路径, 新值)
		return
	case map[string]any:
		_, 返回_错误 = 置值(当前值, 键组路径, 新值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}

func 置值(原始数据 any, 键组路径 []string, 值 any) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("键组路径不能为空")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			当前值[键组路径[0]] = 值
			返回_值 = 当前值
			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])

			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}
			if 错误 != nil {
				返回_错误 = errors.New("切片路径错误:" + 错误.Error())
				return
			}
			switch 新值 := 值.(type) {
			case map[string]any:
				当前值[位置] = 新值
				返回_值 = 当前值
				return

			default:
				当前值[位置] = 新值
			}

			//当前值[位置] = 值
			返回_值 = 当前值
			return
		default:
			添加值 := make(map[string]any)
			添加值[键组路径[0]] = 值
			返回_值 = 添加值
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		当前值[键组路径[0]], 返回_错误 = 置值(当前值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(原始数据.([]any))-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("切片路径错误:" + 错误.Error())
			return
		}
		当前值[位置], 返回_错误 = 置值(当前值[位置], 键组路径[1:], 值)
		return 当前值, 返回_错误

	default:

		添加值 := make(map[string]any)
		添加值[键组路径[0]] = 键组路径[1]
		当前值 = 添加值
		当前值.(map[string]any)[键组路径[0]], 返回_错误 = 置值(添加值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	}

}

func 键值列表_子切片添加值(原始数据 any, 键组路径 []string, 值 any) (返回_错误 error) {
	返回_错误 = 键值列表_类型筛选(值)
	if 返回_错误 != nil {
		return
	}
	新值, err := 键值列表_深拷贝(值)
	if err != nil {
		switch 当前值 := 原始数据.(type) {
		case []any:
			_, 返回_错误 = 子切片添加值(当前值, 键组路径, 值)
			return
		case map[string]any:
			_, 返回_错误 = 子切片添加值(当前值, 键组路径, 值)
			return
		default:
			返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case []any:
		_, 返回_错误 = 子切片添加值(当前值, 键组路径, 新值)
		return
	case map[string]any:
		_, 返回_错误 = 子切片添加值(当前值, 键组路径, 新值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}
func 子切片添加值(原始数据 any, 键组路径 []string, 值 any) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		switch 当前值 := 原始数据.(type) {
		case []any:
			当前值 = append(当前值, 值)
			返回_值 = 当前值
			return
		default:
			返回_错误 = errors.New("错误:键路径  不存在 或者 不为[]any")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		当前值[键组路径[0]], 返回_错误 = 子切片添加值(当前值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(原始数据.([]any))-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("切片路径错误:" + 错误.Error())
			return
		}
		当前值[位置], 返回_错误 = 子切片添加值(当前值[位置], 键组路径[1:], 值)
		return 当前值, 返回_错误
	default:

		返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在 或者 不为[]any | map[string]any")
		return 当前值, 返回_错误
	}

}

func 键值列表_取值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值, 返回_错误 = 取值(当前值, 键组路径)

	case map[string]any:
		返回_值, 返回_错误 = 取值(当前值, 键组路径)

	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}
	值, err := 键值列表_深拷贝(返回_值)
	if err != nil {
		return
	}
	返回_值 = 值
	return

}

func 取值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("路径错误:路径长度不能为0")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			值, ok := 当前值[键组路径[0]]
			if ok {
				返回_值 = 值
			} else {
				返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			}

			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])

			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}
			if 错误 != nil {
				返回_错误 = errors.New("路径错误:" + 错误.Error())
				return
			}
			返回_值 = 当前值[位置]
			return
		default:
			返回_错误 = errors.New("路径错误:非有效路径")
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:

		值, ok := 当前值[键组路径[0]]
		if !ok {
			返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			return
		}
		返回_值, 返回_错误 = 取值(值, 键组路径[1:])
		return
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(当前值)-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 位置 < 0 {
			返回_错误 = errors.New("路径错误:切片置值不能<0")
			return
		}

		if 错误 != nil {
			返回_错误 = errors.New("路径错误:" + 错误.Error())
			return
		}
		返回_值, 返回_错误 = 取值(当前值[位置], 键组路径[1:])
		return
	default:
		返回_错误 = errors.New("路径错误:非有效路径")
		return
	}

}

// []any 或者 map[string]any
func 键值列表_删除值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {

	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值, 返回_错误 = 删除值(当前值, 键组路径)
		return
	case map[string]any:
		返回_值, 返回_错误 = 删除值(当前值, 键组路径)
		return
	default:
		返回_值 = 原始数据
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}
func 删除值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("路径错误:路径长度不能为0")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			_, ok := 当前值[键组路径[0]]
			if ok {
				delete(当前值, 键组路径[0])
				返回_值 = 当前值
			} else {
				返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			}
			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])
			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}

			if 错误 != nil {
				返回_错误 = errors.New("路径错误:" + 错误.Error())
				return
			}
			//fmt.Println(len(当前值[:位置]))
			//fmt.Println(len(当前值[位置+1:]))
			if len(当前值) == 1 {
				返回_值 = 当前值[:位置]
				return
			} else if len(当前值[:位置]) == 0 && len(当前值[位置+1:]) != 0 {
				返回_值 = 当前值[位置+1:]
				return
			} else if len(当前值[:位置]) != 0 && len(当前值[位置+1:]) == 0 {
				返回_值 = 当前值[:位置]
				return
			} else {
				当前值 = append(当前值[:位置], 当前值[位置+1:]...)
				返回_值 = 当前值
			}
			return
		default:
			返回_错误 = errors.New("路径错误:非有效路径")
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		值, ok := 当前值[键组路径[0]]
		if !ok {
			返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			return
		}
		返回_值, 返回_错误 = 删除值(值, 键组路径[1:])
		return
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(当前值)-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 位置 < 0 {
			返回_错误 = errors.New("路径错误:切片置值不能<0")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("路径错误:" + 错误.Error())
			return
		}
		返回_值, 返回_错误 = 删除值(当前值[位置], 键组路径[1:])
		return
	default:
		返回_错误 = errors.New("路径错误:非有效路径")
		return
	}

}

// func 键值列表_路径分割(路径 string) (返回_值 []string) {
// 	返回_值 = 路径分割(路径, ".", false)
// 	for i, v := range 返回_值 {
// 		//全_文本.PDQ_判断前缀(v, "[")
// 		if len(v) >= 3 && 全_文本.PDQ_判断前缀(v, "[") && 全_文本.PDH_判断后缀(v, "]") {
// 			返回_值[i] = v[1 : len(v)-1]
// 		}
// 	}
// 	return
// }

// func 路径分割(路径 string, sep string, 保持符号 bool) (返回_值 []string) {
// 	//sep := "."
// 	separator := sep
// 	keepQuotes := 保持符号
// 	singleQuoteOpen := false
// 	doubleQuoteOpen := false
// 	var tokenBuffer []string
// 	var ret []string

// 	arr := 全_文本.FGW_分割文本(路径, "")
// 	for _, element := range arr {
// 		matches := false
// 		if separator == element {
// 			matches = true
// 		}

// 		if element == "'" && !doubleQuoteOpen {
// 			if keepQuotes {
// 				tokenBuffer = append(tokenBuffer, element)
// 			}
// 			singleQuoteOpen = !singleQuoteOpen
// 			continue
// 		} else if element == `"` && !singleQuoteOpen {
// 			if keepQuotes {
// 				tokenBuffer = append(tokenBuffer, element)
// 			}
// 			doubleQuoteOpen = !doubleQuoteOpen
// 			continue
// 		}

// 		if !singleQuoteOpen && !doubleQuoteOpen && matches {
// 			if len(tokenBuffer) > 0 {
// 				ret = append(ret, 全_文本.HBW_合并文本_切片(tokenBuffer, ""))
// 				tokenBuffer = make([]string, 0)
// 			} else if sep != "" {
// 				ret = append(ret, element)
// 			}
// 		} else {
// 			tokenBuffer = append(tokenBuffer, element)
// 		}
// 	}
// 	if len(tokenBuffer) > 0 {
// 		ret = append(ret, 全_文本.HBW_合并文本_切片(tokenBuffer, ""))
// 	} else if sep != "" {
// 		ret = append(ret, "")
// 	}
// 	return ret
// }

// 按照条件 和 非条件 分割  被' '包裹的 不会被分割 如果 ”内有'  可以用 " \\' "  或者是 ` \' `
func 键值列表_条件分割(原始文本 string, 条件组 []string) (返回_值 []string) {
	分段文本 := strings.Split(原始文本, "")
	组文本 := ""
	截断 := false
	要执行 := false
	for i, v := range 分段文本 {
		组文本 = 组文本 + v

		if v == "'" {

			截断 = !截断
			要执行 = true
			if i > 0 && 分段文本[i-1] == `\` {
				截断 = !截断
				要执行 = false
			}

		}
		if 截断 && 要执行 {
			要执行 = false
			组文本 = 组文本[:len(组文本)-1]
			文本 := 条件分割_加空格(组文本, 条件组, 条件组)
			当前组 := strings.Fields(文本)
			返回_值 = append(返回_值, 当前组...)
			组文本 = "'"
		} else if !截断 && 要执行 {
			要执行 = false
			返回_值 = append(返回_值, 组文本)
			组文本 = ""

		}

	}
	if len(组文本) > 0 {
		文本 := 条件分割_加空格(组文本, 条件组, 条件组)
		当前组 := strings.Fields(文本)
		返回_值 = append(返回_值, 当前组...)

	}
	for i, v := range 返回_值 {
		返回_值[i] = strings.Replace(v, `\'`, "'", -1)

	}
	return
}
func 条件分割_加空格(原始文本 string, 条件组, 参照组 []string) (返回值 string) {
	条件数 := len(条件组)
	if 条件数 == 0 {
		return
	}
	条件值 := 条件组[0]
	if 条件数 == 1 {
		分割组 := strings.Split(原始文本, 条件值)
		组数 := len(分割组)
		当前组 := make([]string, 0)

		for i, v := range 分割组 {
			if i == 组数-1 {
				当前组 = append(当前组, v)

			} else {
				当前组 = append(当前组, v, 条件值)
			}

		}
		返回值 = strings.Join(当前组, " ")
		return
	}

	分割组 := strings.Split(原始文本, 条件值)
	组数 := len(分割组)
	当前组 := make([]string, 0)

	for i, v := range 分割组 {
		if i == 组数-1 {
			当前组 = append(当前组, v)

		} else {
			当前组 = append(当前组, v, 条件值)
		}

	}
	for i, v := range 当前组 {
		重复 := false
		for _, X := range 参照组 {
			if X == v {
				重复 = true
				break
			}
		}
		if !重复 {
			当前组[i] = 条件分割_加空格(v, 条件组[1:], 参照组)
		}
	}
	返回值 = strings.Join(当前组, " ")

	return
}

// 判断 数组里 ( 和 ) 的成对 位置越前的越有括号优先级 并返回 括号顺序的 位置数组
func 键值列表_查询_括号位置算法(条件组 []string) (返回位置组 [][]int, 返回_错误 error) {
	返回位置组, 返回_错误 = 括号位置算法(条件组, -1)
	if 返回_错误 != nil {
		return
	}
	存在 := false
	for i, v := range 条件组 {
		if v == ")" {
			存在 = false
			for _, 位置 := range 返回位置组 {
				if i == 位置[1] {
					存在 = true
				}
			}
			if !存在 {
				返回_错误 = errors.New("错误:括号不对称,多了 ) 号")
				return
			}
		}

	}
	return
}

func 括号位置算法(条件组 []string, 左开始位置 int) (返回位置组 [][]int, 返回_错误 error) {
	开始括号位置 := -1
	开始括号数 := 0
	//结束括号位置 := -1
	结束括号数 := 0
	for i, v := range 条件组 {

		if 开始括号位置 == -1 && v == "(" {
			if i > 左开始位置 {
				开始括号位置 = i
				开始括号数++
			}
		} else if 开始括号位置 != -1 && v == "(" {
			if i > 左开始位置 {
				开始括号数++
			}
		} else if 开始括号位置 != -1 && v == ")" {
			if i > 左开始位置 {
				结束括号数++
			}
			if 开始括号数 == 结束括号数 {
				括号位置组 := []int{开始括号位置, i}
				返回位置组, 返回_错误 = 括号位置算法(条件组, 开始括号位置)
				返回位置组 = append(返回位置组, 括号位置组)
				return

			}

		}
		// else if 开始括号位置 != -1 && v == ")" && i> 左开始位置{
		// 	fmt.Println(99999,i,左开始位置,v)
		// 	//右括号存在=true
		// }

	}

	if 开始括号数 != 结束括号数 {

		返回_错误 = errors.New("错误:括号不对称,少了 ) 号")
		return

	}

	//fmt.Println("开始括号数,结束括号数", 开始括号数, 结束括号数)
	return
}

// 可以将 带有 ()+-*/ 数字 文本  和其他符号的 文本  分割后成数组后 拿进来用  会自动 计算 里面的 +-*/ 并 按优先级处理掉括号
func 键值列表_查询_加减乘除_按顺序处理算法(条件组 []string) (返回_结果组 []string, 返回_错误 error) {
	//fmt.Println(1, 条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {
		if v == "*" || v == "/" || v == "%" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误")
				return
			}
			左, err1 := strconv.ParseFloat(条件组[i-1], 64)
			右, err2 := strconv.ParseFloat(条件组[i+1], 64)
			if err1 != nil && err2 != nil {
				if 条件组[i-1] == ")" && 条件组[i+1] == "(" {

				} else {
					返回_错误 = errors.New("错误: 符号" + v + " 计算类型错误")
					return

				}

			} else if err1 == nil && err2 == nil {
				值 := 0.0
				if v == "*" {
					值 = 左 * 右
				} else if v == "/" {
					值 = 左 / 右
				} else {
					值 = float64(int(左) % int(右))
				}

				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_结果组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_结果组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_结果组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_结果组 = 新组
				}

				if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {

					if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_结果组[:i-2]...)
						新组 = append(新组, 返回_结果组[i-1])
						if i+1 <= len(返回_结果组) {
							新组 = append(新组, 返回_结果组[i+1:]...)
						}

						返回_结果组 = 新组
					}
				}
				返回_结果组, 返回_错误 = 键值列表_查询_加减乘除_按顺序处理算法(返回_结果组)
				return

			}

		}

	}

	for i, v := range 条件组 {
		if v == "+" || v == "-" {
			if i == 0 {
				if v == "-" && 组长 >= 2 {
					新组 := make([]string, 0)
					值 := v + 条件组[1]
					新组 = append(新组, 值)
					if 组长 >= 3 {
						新组 = append(新组, 条件组[i+2:]...)
					}
					返回_结果组 = 新组
					if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {
						if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {

							新组 := make([]string, 0)
							新组 = append(新组, 返回_结果组[:i-2]...)
							新组 = append(新组, 返回_结果组[i-1])
							if i+1 <= len(返回_结果组) {
								新组 = append(新组, 返回_结果组[i+1:]...)
							}

							返回_结果组 = 新组
						}
					}

					返回_结果组, 返回_错误 = 键值列表_查询_加减乘除_按顺序处理算法(返回_结果组)
					return

				}
				返回_错误 = errors.New("错误: * 位置错误1")
				return
			}
			if i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误2")
				return
			}

			左, err1 := strconv.ParseFloat(条件组[i-1], 64)

			右, err2 := strconv.ParseFloat(条件组[i+1], 64)
			值 := ""
			if err1 != nil && err2 != nil {
				if v == "+" && strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'") && strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'") {
					值 = 条件组[i-1][:len(条件组[i-1])-1] + 条件组[i+1][1:len(条件组[i+1])]
					// 值 = 条件组[i-1] + 条件组[i+1]
					// 值 = strings.Replace(值, "'", "", -1)
					// 值 = "'" + 值 + "'"
				} else if 条件组[i-1] == ")" && 条件组[i+1] == "(" {
					continue

				} else if v == "-" && 条件组[i+1] == "(" {
					continue
				} else {
					返回_错误 = errors.New("错误: 符号" + v + " 计算类型错误")
					return
				}

			} else if err1 == nil && err2 == nil {

				if v == "+" {
					值 = fmt.Sprintf("%v", 左+右)
				} else {
					值 = fmt.Sprintf("%v", 左-右)
				}
			} else if err1 != nil && err2 == nil && v == "-" {
				新组 := make([]string, 0)
				值内 := v + 条件组[i+1]
				新组 = append(新组, 条件组[:i]...)
				新组 = append(新组, 值内)
				if 组长 >= i+3 {
					新组 = append(新组, 条件组[i+2:]...)
				}
				返回_结果组 = 新组
				if len(返回_结果组) >= 3 && i >= 1 && i+2 <= len(返回_结果组) {

					if 返回_结果组[i-1] == "(" && 返回_结果组[i+1] == ")" {

						新组 := make([]string, 0)
						新组 = append(新组, 返回_结果组[:i-1]...)
						新组 = append(新组, 返回_结果组[i])
						if i+2 <= len(返回_结果组) {
							新组 = append(新组, 返回_结果组[i+2:]...)
						}

						返回_结果组 = 新组

					}
				}

				返回_结果组, 返回_错误 = 键值列表_查询_加减乘除_按顺序处理算法(返回_结果组)
				return

			} else if (err1 == nil || err2 == nil) && v == "+" {
				if (strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'")) || (strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'")) {
					值1 := ""
					值2 := ""
					if strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'") {
						值1 = 条件组[i-1][:len(条件组[i-1])-1]
					} else {
						值1 = "'" + 条件组[i-1]
					}
					if strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'") {
						值2 = 条件组[i+1][1:len(条件组[i+1])]
					} else {
						值2 = 条件组[i+1] + "'"
					}
					值 = 值1 + 值2
				} else {
					continue
				}
			} else {

				continue
			}

			if i <= 1 && i >= 组长-2 {
				新组 := []string{值}
				返回_结果组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				返回_结果组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			}
			if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {

				if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {
					新组 := make([]string, 0)
					新组 = append(新组, 返回_结果组[:i-2]...)
					新组 = append(新组, 返回_结果组[i-1])
					if i+1 <= len(返回_结果组) {
						新组 = append(新组, 返回_结果组[i+1:]...)
					}

					返回_结果组 = 新组
				}
			}

			返回_结果组, 返回_错误 = 键值列表_查询_加减乘除_按顺序处理算法(返回_结果组)
			return
		}
	}

	返回_结果组 = 条件组
	if len(返回_结果组) == 3 {

		if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
			新组 := make([]string, 0)
			新组 = append(新组, 返回_结果组[1])
			返回_结果组 = 新组
			return
		}
	}
	return
}

// 条件数组内 有 独立的  = > < >= <= !=  ~= !~=  符合两边有 文本或者数值  会判断 并用 文本型的 ture 或者 false 替换掉
func 键值列表_查询_等式逻辑处理(条件组 []string) (返回_组 []string, 返回_错误 error) {
	//fmt.Println(条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {
		if v == "=" || v == ">" || v == ">=" || v == "<" || v == "<=" || v == "!=" || v == "~=" || v == "!~=" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			_, err1 := strconv.ParseFloat(条件组[i-1], 64)
			if err1 != nil && !strings.HasPrefix(条件组[i-1], "'") && !strings.HasSuffix(条件组[i-1], "'") {
				返回_错误 = errors.New("错误:判断符 " + 条件组[i-1] + v + " 错误")
				return
			}
			_, err2 := strconv.ParseFloat(条件组[i+1], 64)
			if err2 != nil && !strings.HasPrefix(条件组[i+1], "'") && !strings.HasSuffix(条件组[i+1], "'") {
				返回_错误 = errors.New("错误:判断符 " + 条件组[i+1] + v + " 错误")
				return
			}

			值 := 等式逻辑处理(条件组[i-1], v, 条件组[i+1])

			if i <= 1 && i >= 组长-2 {
				新组 := []string{fmt.Sprintf("%v", 值)}
				返回_组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				返回_组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_组 = 新组
			}
			返回_组, 返回_错误 = 键值列表_查询_等式逻辑处理(返回_组)
			return

		}

	}
	返回_组 = 条件组
	return
}

// 以 原始文本 的数据类型为基准  进行类型转换->判断文本或数值比较    若类型转换失败 则以文本类型判断
// 如 "原始文本" = "判断文本"  返回判断结果
// 支持  = > < >= <= !=  ~= !~=
func 等式逻辑处理(原始文本, 判断符, 判断文本 string) (返回_值 bool) {

	if 判断符 == "=" {
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				返回_值 = 原始文本 == 判断文本
				return
			} else {
				返回_值 = 原始文本 == ("'" + 判断文本 + "'")
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 == 新值
				// 数值2, err := strconv.ParseFloat(新值, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 ==新值
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 == 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 == 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 == 数值2

				return
			}
		}

	} else if 判断符 == "!=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				返回_值 = 原始文本 != 判断文本
				return
			} else {
				返回_值 = 原始文本 != ("'" + 判断文本 + "'")
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 != 新值
				// 数值2, err := strconv.ParseFloat(新值, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 !=新值
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 != 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 == 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 == 数值2

				//返回_值 = 原始文本 != 判断文本
				return
			}
		}
	} else if 判断符 == ">" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 > 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 > 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 > 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 > 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 > 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 > 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 > 数值2
				return
			}
		}
	} else if 判断符 == "<" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 < 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 < 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 < 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 < 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 < 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 < 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 < 数值2
				return
			}
		}
	} else if 判断符 == "<=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 <= 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 <= 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 <= 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 <= 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 <= 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 <= 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 <= 数值2
				return
			}
		}
	} else if 判断符 == ">=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 >= 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 >= 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 >= 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 >= 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 >= 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 >= 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 >= 数值2
				return
			}
		}
	} else if 判断符 == "~=" {
		新值1 := ""
		新值2 := ""
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本
			}
		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本
				新值2 = 判断文本
			}
		}

		if 新值1 == "" && 新值2 == "" {
			返回_值 = true
			return
		} else if 新值2 == "" {
			返回_值 = false
			return
		}
		if strings.HasPrefix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.HasSuffix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = strings.HasPrefix(新值1, 返回切片[0])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.ContainsAny(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			
			if len(返回切片) == 2 {
				返回_值 = strings.HasPrefix(新值1, 返回切片[0]) && strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else {
			返回_值 = strings.Contains(新值1, 新值2)
			//返回_值 = strings.ContainsAny(新值1, 新值2)
			return
		}

	} else if 判断符 == "!~=" {
		新值1 := ""
		新值2 := ""
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本
			}
		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本
				新值2 = 判断文本
			}
		}

		if 新值1 == "" && 新值2 == "" {
			返回_值 = false
			return
		} else if 新值2 == "" {
			返回_值 = false
			return
		}
		if strings.HasPrefix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.HasSuffix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !strings.HasPrefix(新值1, 返回切片[0])
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.ContainsAny(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !(strings.HasPrefix(新值1, 返回切片[0]) && strings.HasSuffix(新值1, 返回切片[1]))
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else {
			返回_值 = strings.Index(新值1, 新值2) <= -1
			//返回_值 = !strings.ContainsAny(新值1, 新值2)
			return
		}

	}
	return
}

// 如 [( false !! true ) && true] 这样的文本数组  最后会自动 计算 并返回 [true]  这样的文件结果数组 ,,,返回值 有  [true]  [false]
func 键值列表_查询_文本逻辑处理算法(条件组 []string) (返回_组 []string, 返回_错误 error) {
	//fmt.Println(条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {

		if v == "&&" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			if (条件组[i-1] == "true" || 条件组[i-1] == "false") && (条件组[i+1] == "true" || 条件组[i+1] == "false") {

				值1, err1 := strconv.ParseBool(条件组[i-1])
				if err1 != nil {
					err1 = 返回_错误
					return
				}
				值2, err2 := strconv.ParseBool(条件组[i+1])
				if err2 != nil {
					err1 = 返回_错误
					return
				}
				值 := 值1 && 值2
				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				}
				if len(返回_组) >= 3 && i >= 2 && i+1 <= len(返回_组) {

					if 返回_组[i-2] == "(" && 返回_组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_组[:i-2]...)
						新组 = append(新组, 返回_组[i-1])
						if i+1 <= len(返回_组) {
							新组 = append(新组, 返回_组[i+1:]...)
						}

						返回_组 = 新组
					}
				}

				返回_组, 返回_错误 = 键值列表_查询_文本逻辑处理算法(返回_组)
				return

			}

		}

	}

	for i, v := range 条件组 {

		if v == "||" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			if (条件组[i-1] == "true" || 条件组[i-1] == "false") && (条件组[i+1] == "true" || 条件组[i+1] == "false") {

				值1, err1 := strconv.ParseBool(条件组[i-1])
				if err1 != nil {
					err1 = 返回_错误
					return
				}
				值2, err2 := strconv.ParseBool(条件组[i+1])
				if err2 != nil {
					err1 = 返回_错误
					return
				}
				值 := 值1 || 值2
				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				}
				if len(返回_组) >= 3 && i >= 2 && i+1 <= len(返回_组) {

					if 返回_组[i-2] == "(" && 返回_组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_组[:i-2]...)
						新组 = append(新组, 返回_组[i-1])
						if i+1 <= len(返回_组) {
							新组 = append(新组, 返回_组[i+1:]...)
						}

						返回_组 = 新组
					}
				}

				返回_组, 返回_错误 = 键值列表_查询_文本逻辑处理算法(返回_组)
				return

			}

		}

	}
	返回_组 = 条件组
	//fmt.Println("最后结果",结果组)
	if len(返回_组) != 1 {
		返回_错误 = errors.New("错误:查询语法错误")
		return
	}
	if 返回_组[0] != "true" && 返回_组[0] != "false" {
		返回_错误 = errors.New("错误:查询语法错误")
		return
	}

	return
}

// 列表 内部用
func m_map查询_带参数(分割条件, 条件切片 []string, 被查询map map[string]any) (返回_值 bool, 返回_错误 error) {
	返回_值 = false
	存在 := false

	for i, v := range 条件切片 {
		if strings.HasPrefix(v, "'") && strings.HasSuffix(v, "'") {

			continue
		}
		_, err := strconv.ParseFloat(v, 64)
		if err == nil {

			continue
		}

		存在 = false
		for _, vv := range 分割条件 {
			if v == vv {
				存在 = true
				break
			}
		}
		if 存在 {

			continue
		}

		结果, ok := 被查询map[v]

		if !ok {
			//返回_错误 = errors.New("错误: " + v + " 不存在")
			return
		}
		文本 := any_到文本(结果)
		_, err1 := strconv.ParseFloat(文本, 64)
		if err1 == nil {
			条件切片[i] = 文本
		} else {
			条件切片[i] = "'" + 文本 + "'"
		}
	}

	//fmt.Println(条件切片)
	结果切片, err := 键值列表_查询_加减乘除_按顺序处理算法(条件切片)
	if err != nil {
		返回_错误 = err
		return
	}
	//fmt.Println(结果切片)
	_, err2 := 键值列表_查询_括号位置算法(结果切片)
	if err2 != nil {
		返回_错误 = err2
		return
	}
	//fmt.Println(返回位置组)

	for _, v := range 结果切片 {
		if v == "+" || v == "-" || v == "*" || v == "/" || v == "%" {
			返回_错误 = errors.New("错误:运算符 " + v + " 残余错误")
			return
		}

	}
	逻辑切片, err3 := 键值列表_查询_等式逻辑处理(结果切片)
	if err3 != nil {
		返回_错误 = err3
		return
	}
	//fmt.Println(逻辑切片)
	结果组, err4 := 键值列表_查询_文本逻辑处理算法(逻辑切片)
	if err4 != nil {
		返回_错误 = err4
		return
	}
	// //fmt.Println("最后结果",结果组)
	// if len(结果组) != 1 {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }
	// if 结果组[0] != "true" && 结果组[0] != "false" {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }

	返回_值, 返回_错误 = strconv.ParseBool(结果组[0])
	return
}

func 值列路径(路径或索引 any, 索引 ...any) (路径组 []string, 返回_错误 error) {
	索引组 := append([]any{路径或索引}, 索引...)
	var 路径的组 = make([]string, len(索引组))
	for i, v := range 索引组 {
		路径的组[i] = fmt.Sprintf("%v", v)
	}
	路径 := strings.Join(路径的组, ".")
	路径组 =strings.Split(路径, ".")
	for i, 值 := range 路径组 {
		if len(值) >= 3 && strings.HasPrefix(值, "[") && strings.HasSuffix(值, "]") {
			路径组[i] = 值[1 : len(值)-1]
		}
	}

	if len(路径组) == 0 {
		返回_错误 = errors.New("错误:路径解析错误,路径不能为空")
		return
	}
	return

}
